package day2;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/*
 * 递归调用：
 * 递归调用查找最大值，实际与循环遍历达到相同的效果
 * 
 */
public class Recursive {
    public static int getMaxValue(int[] array){
        return process(array,0,array.length-1);
    }

    private static int process(int[] array, int left, int right) {
            if (left==right) {
                return array[left];
            }
    
            //防止溢出
            int mid=left+((right-left)>>1);
            int leftMax=process(array, left, mid);
            int rightMax=process(array, mid+1, right);
            return Math.max(leftMax, rightMax);
        
    }

    /*======================对数器的实现============================= */ 

    public static void main(String[] args) {
        int testTime =2; //测试次数
        int maxSize=5; //数组最大长度
        int maxValue=100; //数组最大值
        boolean succeed=true;

        for (int i = 0; i < testTime; i++) {
            int[] array1=generateRadomArray(maxSize,maxValue);
            int[] array2=copyArray(array1);
            int maxResult1 = getMaxValue(array1);;
            int maxResult2 = comparator(array2);;
            if (!isEqual(maxResult1,maxResult2)) {
                succeed=false;
                break;
            }
        }
        System.out.println(succeed?"Nice!":"Very bad!");

        int[] array=generateRadomArray(maxSize,maxValue);
        printArray(array);
        int maxValue3 = getMaxValue(array);
        System.out.println("max:"+maxValue3);
    }

    private static void printArray(int[] array) {
        System.out.println("[ ");
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]+" ");
        }
        System.out.print("]");
        System.out.println(" ");
    }

    private static boolean isEqual(int num1, int num2) {
        return num1==num2;
    }

    //jdk提供的已知正确方法，用于对比需要测试的算法
    private static int comparator(int[] array) {
        List<Integer> asList = Arrays.stream(array).boxed().collect(Collectors.toList());
        return Collections.max(asList);
        // return asList.stream().max(Comparator.comparing(x->x)).orElse(null);
    }

    /**
     * 复制数组
     * @param array 愿数组
     * @return 复制的新数组
     */
    private static int[] copyArray(int[] array) {
        if (array==null) {
            return null;
        }

        int[] res=new int[array.length];
        for (int i = 0; i < array.length; i++) {
            res[i]=array[i];
        }
        return res;
    }

    /**
     * 生成随机长度、包含随机值的数组
     * @param maxSize 数组最大长度
     * @param maxValue 数组中的值最大值
     * @return 生成的数组
     */
    private static int[] generateRadomArray(int maxSize, int maxValue) {
        
        /**
         * 
         * Math.random()->[0,1)所有小数，等概率返回。
         * 因为计算机有精度因此可以穷尽，数学则无法做到
         * 
         * Math.random()*N->[0,N)所有小数，等概率返回。
         * 
         * (int)(Math.random()*N)->[0,N-1]所有整数，等概率返回
         * 
         */
        
         //生成随机长度的数组
         int[] array=new int[(int) ((maxSize+1)*Math.random())];

         //使用随机数初始化数组
         for (int i = 0; i < array.length; i++) {
            array[i]=(int) ((maxValue+1)*Math.random())-(int)((maxValue)*Math.random());
         }

        return array;
    }
}
